/*
wellbye：这个文件是自动生成的，不要手工修改！ 
*/
using System;
using ILRuntime.CLR.Method;
using ILRuntime.Other;
using ILRuntime.Runtime.Enviorment;
using ILRuntime.Runtime.Intepreter;

[ILRAdaptor]
public class ILRAdaptor_UICollectionViewController : CrossBindingAdaptor
{
    public override Type BaseCLRType { get { return typeof(UIKit.UICollectionViewController); } }
    public override Type AdaptorType { get { return typeof(Adaptor); } }

    public override object CreateCLRInstance(ILRuntime.Runtime.Enviorment.AppDomain appDomain, ILTypeInstance instance)
    {
        return new Adaptor(appDomain, instance); //创建一个新的实例
    }

    //实际的适配器类需要继承你想继承的那个类，并且实现CrossBindingAdaptorType接口
    public class Adaptor : UIKit.UICollectionViewController, CrossBindingAdaptorType
    {
        ILTypeInstance instance;
        ILRuntime.Runtime.Enviorment.AppDomain appDomain;

        public Adaptor() { }

        public Adaptor(ILRuntime.Runtime.Enviorment.AppDomain appDomain, ILTypeInstance instance)
        {
            this.appDomain = appDomain;
            this.instance = instance;
        }

        public ILTypeInstance ILInstance { get { return instance; } }

        
        
        IMethod methodCanFocusItem0;
        bool isCallingCanFocusItem0= false;
        
            public override System.Boolean CanFocusItem(UIKit.UICollectionView p0, Foundation.NSIndexPath p1) 
            { 
                if (methodCanFocusItem0 == null && instance!=null )
                {
                    methodCanFocusItem0 = instance.Type.GetMethod("CanFocusItem", 2);
                }
                if (methodCanFocusItem0 != null && !isCallingCanFocusItem0)
                {
                    isCallingCanFocusItem0 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                                p1,
                        };
                        object ret = appDomain.Invoke(methodCanFocusItem0, instance, param );
                        
                        
                        isCallingCanFocusItem0 = false;

                        
                        return (System.Boolean)ret;
                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In CanFocusItem *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                            return base.CanFocusItem(p0, p1);
                        
                    

                }
            }
        
        
        
        IMethod methodCanMoveItem1;
        bool isCallingCanMoveItem1= false;
        
            public override System.Boolean CanMoveItem(UIKit.UICollectionView p0, Foundation.NSIndexPath p1) 
            { 
                if (methodCanMoveItem1 == null && instance!=null )
                {
                    methodCanMoveItem1 = instance.Type.GetMethod("CanMoveItem", 2);
                }
                if (methodCanMoveItem1 != null && !isCallingCanMoveItem1)
                {
                    isCallingCanMoveItem1 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                                p1,
                        };
                        object ret = appDomain.Invoke(methodCanMoveItem1, instance, param );
                        
                        
                        isCallingCanMoveItem1 = false;

                        
                        return (System.Boolean)ret;
                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In CanMoveItem *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                            return base.CanMoveItem(p0, p1);
                        
                    

                }
            }
        
        
        
        IMethod methodCanPerformAction2;
        bool isCallingCanPerformAction2= false;
        
            public override System.Boolean CanPerformAction(UIKit.UICollectionView p0, ObjCRuntime.Selector p1, Foundation.NSIndexPath p2, Foundation.NSObject p3) 
            { 
                if (methodCanPerformAction2 == null && instance!=null )
                {
                    methodCanPerformAction2 = instance.Type.GetMethod("CanPerformAction", 4);
                }
                if (methodCanPerformAction2 != null && !isCallingCanPerformAction2)
                {
                    isCallingCanPerformAction2 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                                p1,
                                p2,
                                p3,
                        };
                        object ret = appDomain.Invoke(methodCanPerformAction2, instance, param );
                        
                        
                        isCallingCanPerformAction2 = false;

                        
                        return (System.Boolean)ret;
                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In CanPerformAction *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                            return base.CanPerformAction(p0, p1, p2, p3);
                        
                    

                }
            }
        
        
        
        IMethod methodDidUpdateFocus3;
        bool isCallingDidUpdateFocus3= false;
        
            public override void DidUpdateFocus(UIKit.UICollectionView p0, UIKit.UICollectionViewFocusUpdateContext p1, UIKit.UIFocusAnimationCoordinator p2) 
            { 
                if (methodDidUpdateFocus3 == null && instance!=null )
                {
                    methodDidUpdateFocus3 = instance.Type.GetMethod("DidUpdateFocus", 3);
                }
                if (methodDidUpdateFocus3 != null && !isCallingDidUpdateFocus3)
                {
                    isCallingDidUpdateFocus3 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                                p1,
                                p2,
                        };
                        object ret = appDomain.Invoke(methodDidUpdateFocus3, instance, param );
                        
                        
                        isCallingDidUpdateFocus3 = false;

                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In DidUpdateFocus *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                            base.DidUpdateFocus(p0, p1, p2);
                        
                    

                }
            }
        
        
        
        IMethod methodDidZoom4;
        bool isCallingDidZoom4= false;
        
            public override void DidZoom(UIKit.UIScrollView p0) 
            { 
                if (methodDidZoom4 == null && instance!=null )
                {
                    methodDidZoom4 = instance.Type.GetMethod("DidZoom", 1);
                }
                if (methodDidZoom4 != null && !isCallingDidZoom4)
                {
                    isCallingDidZoom4 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                        };
                        object ret = appDomain.Invoke(methodDidZoom4, instance, param );
                        
                        
                        isCallingDidZoom4 = false;

                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In DidZoom *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                            base.DidZoom(p0);
                        
                    

                }
            }
        
        
        
        IMethod methodItemDeselected5;
        bool isCallingItemDeselected5= false;
        
            public override void ItemDeselected(UIKit.UICollectionView p0, Foundation.NSIndexPath p1) 
            { 
                if (methodItemDeselected5 == null && instance!=null )
                {
                    methodItemDeselected5 = instance.Type.GetMethod("ItemDeselected", 2);
                }
                if (methodItemDeselected5 != null && !isCallingItemDeselected5)
                {
                    isCallingItemDeselected5 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                                p1,
                        };
                        object ret = appDomain.Invoke(methodItemDeselected5, instance, param );
                        
                        
                        isCallingItemDeselected5 = false;

                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In ItemDeselected *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                            base.ItemDeselected(p0, p1);
                        
                    

                }
            }
        
        
        
        IMethod methodItemHighlighted6;
        bool isCallingItemHighlighted6= false;
        
            public override void ItemHighlighted(UIKit.UICollectionView p0, Foundation.NSIndexPath p1) 
            { 
                if (methodItemHighlighted6 == null && instance!=null )
                {
                    methodItemHighlighted6 = instance.Type.GetMethod("ItemHighlighted", 2);
                }
                if (methodItemHighlighted6 != null && !isCallingItemHighlighted6)
                {
                    isCallingItemHighlighted6 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                                p1,
                        };
                        object ret = appDomain.Invoke(methodItemHighlighted6, instance, param );
                        
                        
                        isCallingItemHighlighted6 = false;

                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In ItemHighlighted *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                            base.ItemHighlighted(p0, p1);
                        
                    

                }
            }
        
        
        
        IMethod methodItemSelected7;
        bool isCallingItemSelected7= false;
        
            public override void ItemSelected(UIKit.UICollectionView p0, Foundation.NSIndexPath p1) 
            { 
                if (methodItemSelected7 == null && instance!=null )
                {
                    methodItemSelected7 = instance.Type.GetMethod("ItemSelected", 2);
                }
                if (methodItemSelected7 != null && !isCallingItemSelected7)
                {
                    isCallingItemSelected7 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                                p1,
                        };
                        object ret = appDomain.Invoke(methodItemSelected7, instance, param );
                        
                        
                        isCallingItemSelected7 = false;

                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In ItemSelected *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                            base.ItemSelected(p0, p1);
                        
                    

                }
            }
        
        
        
        IMethod methodItemUnhighlighted8;
        bool isCallingItemUnhighlighted8= false;
        
            public override void ItemUnhighlighted(UIKit.UICollectionView p0, Foundation.NSIndexPath p1) 
            { 
                if (methodItemUnhighlighted8 == null && instance!=null )
                {
                    methodItemUnhighlighted8 = instance.Type.GetMethod("ItemUnhighlighted", 2);
                }
                if (methodItemUnhighlighted8 != null && !isCallingItemUnhighlighted8)
                {
                    isCallingItemUnhighlighted8 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                                p1,
                        };
                        object ret = appDomain.Invoke(methodItemUnhighlighted8, instance, param );
                        
                        
                        isCallingItemUnhighlighted8 = false;

                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In ItemUnhighlighted *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                            base.ItemUnhighlighted(p0, p1);
                        
                    

                }
            }
        
        
        
        IMethod methodShouldDeselectItem9;
        bool isCallingShouldDeselectItem9= false;
        
            public override System.Boolean ShouldDeselectItem(UIKit.UICollectionView p0, Foundation.NSIndexPath p1) 
            { 
                if (methodShouldDeselectItem9 == null && instance!=null )
                {
                    methodShouldDeselectItem9 = instance.Type.GetMethod("ShouldDeselectItem", 2);
                }
                if (methodShouldDeselectItem9 != null && !isCallingShouldDeselectItem9)
                {
                    isCallingShouldDeselectItem9 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                                p1,
                        };
                        object ret = appDomain.Invoke(methodShouldDeselectItem9, instance, param );
                        
                        
                        isCallingShouldDeselectItem9 = false;

                        
                        return (System.Boolean)ret;
                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In ShouldDeselectItem *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                            return default(System.Boolean);
                        
                    

                }
            }
        
        
        
        IMethod methodShouldHighlightItem10;
        bool isCallingShouldHighlightItem10= false;
        
            public override System.Boolean ShouldHighlightItem(UIKit.UICollectionView p0, Foundation.NSIndexPath p1) 
            { 
                if (methodShouldHighlightItem10 == null && instance!=null )
                {
                    methodShouldHighlightItem10 = instance.Type.GetMethod("ShouldHighlightItem", 2);
                }
                if (methodShouldHighlightItem10 != null && !isCallingShouldHighlightItem10)
                {
                    isCallingShouldHighlightItem10 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                                p1,
                        };
                        object ret = appDomain.Invoke(methodShouldHighlightItem10, instance, param );
                        
                        
                        isCallingShouldHighlightItem10 = false;

                        
                        return (System.Boolean)ret;
                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In ShouldHighlightItem *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                            return default(System.Boolean);
                        
                    

                }
            }
        
        
        
        IMethod methodShouldScrollToTop11;
        bool isCallingShouldScrollToTop11= false;
        
            public override System.Boolean ShouldScrollToTop(UIKit.UIScrollView p0) 
            { 
                if (methodShouldScrollToTop11 == null && instance!=null )
                {
                    methodShouldScrollToTop11 = instance.Type.GetMethod("ShouldScrollToTop", 1);
                }
                if (methodShouldScrollToTop11 != null && !isCallingShouldScrollToTop11)
                {
                    isCallingShouldScrollToTop11 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                        };
                        object ret = appDomain.Invoke(methodShouldScrollToTop11, instance, param );
                        
                        
                        isCallingShouldScrollToTop11 = false;

                        
                        return (System.Boolean)ret;
                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In ShouldScrollToTop *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                            return default(System.Boolean);
                        
                    

                }
            }
        
        
        
        IMethod methodShouldSelectItem12;
        bool isCallingShouldSelectItem12= false;
        
            public override System.Boolean ShouldSelectItem(UIKit.UICollectionView p0, Foundation.NSIndexPath p1) 
            { 
                if (methodShouldSelectItem12 == null && instance!=null )
                {
                    methodShouldSelectItem12 = instance.Type.GetMethod("ShouldSelectItem", 2);
                }
                if (methodShouldSelectItem12 != null && !isCallingShouldSelectItem12)
                {
                    isCallingShouldSelectItem12 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                                p1,
                        };
                        object ret = appDomain.Invoke(methodShouldSelectItem12, instance, param );
                        
                        
                        isCallingShouldSelectItem12 = false;

                        
                        return (System.Boolean)ret;
                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In ShouldSelectItem *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                            return default(System.Boolean);
                        
                    

                }
            }
        
        
        
        IMethod methodShouldShowMenu13;
        bool isCallingShouldShowMenu13= false;
        
            public override System.Boolean ShouldShowMenu(UIKit.UICollectionView p0, Foundation.NSIndexPath p1) 
            { 
                if (methodShouldShowMenu13 == null && instance!=null )
                {
                    methodShouldShowMenu13 = instance.Type.GetMethod("ShouldShowMenu", 2);
                }
                if (methodShouldShowMenu13 != null && !isCallingShouldShowMenu13)
                {
                    isCallingShouldShowMenu13 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                                p1,
                        };
                        object ret = appDomain.Invoke(methodShouldShowMenu13, instance, param );
                        
                        
                        isCallingShouldShowMenu13 = false;

                        
                        return (System.Boolean)ret;
                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In ShouldShowMenu *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                            return default(System.Boolean);
                        
                    

                }
            }
        
        
        
        IMethod methodShouldSpringLoadItem14;
        bool isCallingShouldSpringLoadItem14= false;
        
            public override System.Boolean ShouldSpringLoadItem(UIKit.UICollectionView p0, Foundation.NSIndexPath p1, UIKit.IUISpringLoadedInteractionContext p2) 
            { 
                if (methodShouldSpringLoadItem14 == null && instance!=null )
                {
                    methodShouldSpringLoadItem14 = instance.Type.GetMethod("ShouldSpringLoadItem", 3);
                }
                if (methodShouldSpringLoadItem14 != null && !isCallingShouldSpringLoadItem14)
                {
                    isCallingShouldSpringLoadItem14 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                                p1,
                                p2,
                        };
                        object ret = appDomain.Invoke(methodShouldSpringLoadItem14, instance, param );
                        
                        
                        isCallingShouldSpringLoadItem14 = false;

                        
                        return (System.Boolean)ret;
                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In ShouldSpringLoadItem *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                            return default(System.Boolean);
                        
                    

                }
            }
        
        
        
        IMethod methodShouldUpdateFocus15;
        bool isCallingShouldUpdateFocus15= false;
        
            public override System.Boolean ShouldUpdateFocus(UIKit.UICollectionView p0, UIKit.UICollectionViewFocusUpdateContext p1) 
            { 
                if (methodShouldUpdateFocus15 == null && instance!=null )
                {
                    methodShouldUpdateFocus15 = instance.Type.GetMethod("ShouldUpdateFocus", 2);
                }
                if (methodShouldUpdateFocus15 != null && !isCallingShouldUpdateFocus15)
                {
                    isCallingShouldUpdateFocus15 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                                p1,
                        };
                        object ret = appDomain.Invoke(methodShouldUpdateFocus15, instance, param );
                        
                        
                        isCallingShouldUpdateFocus15 = false;

                        
                        return (System.Boolean)ret;
                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In ShouldUpdateFocus *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                            return default(System.Boolean);
                        
                    

                }
            }
        
        
        
        IMethod methodViewForZoomingInScrollView16;
        bool isCallingViewForZoomingInScrollView16= false;
        
            public override UIKit.UIView ViewForZoomingInScrollView(UIKit.UIScrollView p0) 
            { 
                if (methodViewForZoomingInScrollView16 == null && instance!=null )
                {
                    methodViewForZoomingInScrollView16 = instance.Type.GetMethod("ViewForZoomingInScrollView", 1);
                }
                if (methodViewForZoomingInScrollView16 != null && !isCallingViewForZoomingInScrollView16)
                {
                    isCallingViewForZoomingInScrollView16 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                        };
                        object ret = appDomain.Invoke(methodViewForZoomingInScrollView16, instance, param );
                        
                        
                        isCallingViewForZoomingInScrollView16 = false;

                        
                        return (UIKit.UIView)ret;
                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In ViewForZoomingInScrollView *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                            return default(UIKit.UIView);
                        
                    

                }
            }
        
        
        
        IMethod methodWillDisplayCell17;
        bool isCallingWillDisplayCell17= false;
        
            public override void WillDisplayCell(UIKit.UICollectionView p0, UIKit.UICollectionViewCell p1, Foundation.NSIndexPath p2) 
            { 
                if (methodWillDisplayCell17 == null && instance!=null )
                {
                    methodWillDisplayCell17 = instance.Type.GetMethod("WillDisplayCell", 3);
                }
                if (methodWillDisplayCell17 != null && !isCallingWillDisplayCell17)
                {
                    isCallingWillDisplayCell17 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                                p1,
                                p2,
                        };
                        object ret = appDomain.Invoke(methodWillDisplayCell17, instance, param );
                        
                        
                        isCallingWillDisplayCell17 = false;

                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In WillDisplayCell *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                        
                    

                }
            }
        
        
        
        IMethod methodWillDisplaySupplementaryView18;
        bool isCallingWillDisplaySupplementaryView18= false;
        
            public override void WillDisplaySupplementaryView(UIKit.UICollectionView p0, UIKit.UICollectionReusableView p1, System.String p2, Foundation.NSIndexPath p3) 
            { 
                if (methodWillDisplaySupplementaryView18 == null && instance!=null )
                {
                    methodWillDisplaySupplementaryView18 = instance.Type.GetMethod("WillDisplaySupplementaryView", 4);
                }
                if (methodWillDisplaySupplementaryView18 != null && !isCallingWillDisplaySupplementaryView18)
                {
                    isCallingWillDisplaySupplementaryView18 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                                p1,
                                p2,
                                p3,
                        };
                        object ret = appDomain.Invoke(methodWillDisplaySupplementaryView18, instance, param );
                        
                        
                        isCallingWillDisplaySupplementaryView18 = false;

                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In WillDisplaySupplementaryView *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                        
                    

                }
            }
        
        
        
        IMethod methodWillEndDragging19;
        bool isCallingWillEndDragging19= false;
        
            public override void WillEndDragging(UIKit.UIScrollView p0, CoreGraphics.CGPoint p1, ref CoreGraphics.CGPoint p2) 
            { 
                if (methodWillEndDragging19 == null && instance!=null )
                {
                    methodWillEndDragging19 = instance.Type.GetMethod("WillEndDragging", 3);
                }
                if (methodWillEndDragging19 != null && !isCallingWillEndDragging19)
                {
                    isCallingWillEndDragging19 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                                p1,
                                p2,
                        };
                        object ret = appDomain.Invoke(methodWillEndDragging19, instance, param );
                        
                        
                        isCallingWillEndDragging19 = false;

                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In WillEndDragging *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                        
                    

                }
            }
        
        
        
        IMethod methodCanPerformUnwind20;
        bool isCallingCanPerformUnwind20= false;
        
            public override System.Boolean CanPerformUnwind(ObjCRuntime.Selector p0, UIKit.UIViewController p1, Foundation.NSObject p2) 
            { 
                if (methodCanPerformUnwind20 == null && instance!=null )
                {
                    methodCanPerformUnwind20 = instance.Type.GetMethod("CanPerformUnwind", 3);
                }
                if (methodCanPerformUnwind20 != null && !isCallingCanPerformUnwind20)
                {
                    isCallingCanPerformUnwind20 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                                p1,
                                p2,
                        };
                        object ret = appDomain.Invoke(methodCanPerformUnwind20, instance, param );
                        
                        
                        isCallingCanPerformUnwind20 = false;

                        
                        return (System.Boolean)ret;
                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In CanPerformUnwind *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                            return base.CanPerformUnwind(p0, p1, p2);
                        
                    

                }
            }
        
        
        
        IMethod methodDidAnimateFirstHalfOfRotation21;
        bool isCallingDidAnimateFirstHalfOfRotation21= false;
        
            public override void DidAnimateFirstHalfOfRotation(UIKit.UIInterfaceOrientation p0) 
            { 
                if (methodDidAnimateFirstHalfOfRotation21 == null && instance!=null )
                {
                    methodDidAnimateFirstHalfOfRotation21 = instance.Type.GetMethod("DidAnimateFirstHalfOfRotation", 1);
                }
                if (methodDidAnimateFirstHalfOfRotation21 != null && !isCallingDidAnimateFirstHalfOfRotation21)
                {
                    isCallingDidAnimateFirstHalfOfRotation21 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                        };
                        object ret = appDomain.Invoke(methodDidAnimateFirstHalfOfRotation21, instance, param );
                        
                        
                        isCallingDidAnimateFirstHalfOfRotation21 = false;

                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In DidAnimateFirstHalfOfRotation *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                            base.DidAnimateFirstHalfOfRotation(p0);
                        
                    

                }
            }
        
        
        
        IMethod methodDidMoveToParentViewController22;
        bool isCallingDidMoveToParentViewController22= false;
        
            public override void DidMoveToParentViewController(UIKit.UIViewController p0) 
            { 
                if (methodDidMoveToParentViewController22 == null && instance!=null )
                {
                    methodDidMoveToParentViewController22 = instance.Type.GetMethod("DidMoveToParentViewController", 1);
                }
                if (methodDidMoveToParentViewController22 != null && !isCallingDidMoveToParentViewController22)
                {
                    isCallingDidMoveToParentViewController22 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                        };
                        object ret = appDomain.Invoke(methodDidMoveToParentViewController22, instance, param );
                        
                        
                        isCallingDidMoveToParentViewController22 = false;

                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In DidMoveToParentViewController *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                            base.DidMoveToParentViewController(p0);
                        
                    

                }
            }
        
        
        
        IMethod methodDidReceiveMemoryWarning23;
        bool isCallingDidReceiveMemoryWarning23= false;
        
            public override void DidReceiveMemoryWarning() 
            { 
                if (methodDidReceiveMemoryWarning23 == null && instance!=null )
                {
                    methodDidReceiveMemoryWarning23 = instance.Type.GetMethod("DidReceiveMemoryWarning", 0);
                }
                if (methodDidReceiveMemoryWarning23 != null && !isCallingDidReceiveMemoryWarning23)
                {
                    isCallingDidReceiveMemoryWarning23 = true;

                    try{
                        
                        //无参数调用
                        object ret = appDomain.Invoke(methodDidReceiveMemoryWarning23, instance, null );
                        
                        
                        
                        isCallingDidReceiveMemoryWarning23 = false;

                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In DidReceiveMemoryWarning *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                            base.DidReceiveMemoryWarning();
                        
                    

                }
            }
        
        
        
        IMethod methodDidRotate24;
        bool isCallingDidRotate24= false;
        
            public override void DidRotate(UIKit.UIInterfaceOrientation p0) 
            { 
                if (methodDidRotate24 == null && instance!=null )
                {
                    methodDidRotate24 = instance.Type.GetMethod("DidRotate", 1);
                }
                if (methodDidRotate24 != null && !isCallingDidRotate24)
                {
                    isCallingDidRotate24 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                        };
                        object ret = appDomain.Invoke(methodDidRotate24, instance, param );
                        
                        
                        isCallingDidRotate24 = false;

                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In DidRotate *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                            base.DidRotate(p0);
                        
                    

                }
            }
        
        
        
        IMethod methodDidUpdateFocus25;
        bool isCallingDidUpdateFocus25= false;
        
            public override void DidUpdateFocus(UIKit.UIFocusUpdateContext p0, UIKit.UIFocusAnimationCoordinator p1) 
            { 
                if (methodDidUpdateFocus25 == null && instance!=null )
                {
                    methodDidUpdateFocus25 = instance.Type.GetMethod("DidUpdateFocus", 2);
                }
                if (methodDidUpdateFocus25 != null && !isCallingDidUpdateFocus25)
                {
                    isCallingDidUpdateFocus25 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                                p1,
                        };
                        object ret = appDomain.Invoke(methodDidUpdateFocus25, instance, param );
                        
                        
                        isCallingDidUpdateFocus25 = false;

                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In DidUpdateFocus *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                            base.DidUpdateFocus(p0, p1);
                        
                    

                }
            }
        
        
        
        IMethod methodShouldAutorotate26;
        bool isCallingShouldAutorotate26= false;
        
            public override System.Boolean ShouldAutorotate() 
            { 
                if (methodShouldAutorotate26 == null && instance!=null )
                {
                    methodShouldAutorotate26 = instance.Type.GetMethod("ShouldAutorotate", 0);
                }
                if (methodShouldAutorotate26 != null && !isCallingShouldAutorotate26)
                {
                    isCallingShouldAutorotate26 = true;

                    try{
                        
                        //无参数调用
                        object ret = appDomain.Invoke(methodShouldAutorotate26, instance, null );
                        
                        
                        
                        isCallingShouldAutorotate26 = false;

                        
                        return (System.Boolean)ret;
                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In ShouldAutorotate *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                            return default(System.Boolean);
                        
                    

                }
            }
        
        
        
        IMethod methodShouldAutorotateToInterfaceOrientation27;
        bool isCallingShouldAutorotateToInterfaceOrientation27= false;
        
            public override System.Boolean ShouldAutorotateToInterfaceOrientation(UIKit.UIInterfaceOrientation p0) 
            { 
                if (methodShouldAutorotateToInterfaceOrientation27 == null && instance!=null )
                {
                    methodShouldAutorotateToInterfaceOrientation27 = instance.Type.GetMethod("ShouldAutorotateToInterfaceOrientation", 1);
                }
                if (methodShouldAutorotateToInterfaceOrientation27 != null && !isCallingShouldAutorotateToInterfaceOrientation27)
                {
                    isCallingShouldAutorotateToInterfaceOrientation27 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                        };
                        object ret = appDomain.Invoke(methodShouldAutorotateToInterfaceOrientation27, instance, param );
                        
                        
                        isCallingShouldAutorotateToInterfaceOrientation27 = false;

                        
                        return (System.Boolean)ret;
                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In ShouldAutorotateToInterfaceOrientation *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                            return default(System.Boolean);
                        
                    

                }
            }
        
        
        
        IMethod methodShouldPerformSegue28;
        bool isCallingShouldPerformSegue28= false;
        
            public override System.Boolean ShouldPerformSegue(System.String p0, Foundation.NSObject p1) 
            { 
                if (methodShouldPerformSegue28 == null && instance!=null )
                {
                    methodShouldPerformSegue28 = instance.Type.GetMethod("ShouldPerformSegue", 2);
                }
                if (methodShouldPerformSegue28 != null && !isCallingShouldPerformSegue28)
                {
                    isCallingShouldPerformSegue28 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                                p1,
                        };
                        object ret = appDomain.Invoke(methodShouldPerformSegue28, instance, param );
                        
                        
                        isCallingShouldPerformSegue28 = false;

                        
                        return (System.Boolean)ret;
                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In ShouldPerformSegue *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                            return default(System.Boolean);
                        
                    

                }
            }
        
        
        
        IMethod methodShouldUpdateFocus29;
        bool isCallingShouldUpdateFocus29= false;
        
            public override System.Boolean ShouldUpdateFocus(UIKit.UIFocusUpdateContext p0) 
            { 
                if (methodShouldUpdateFocus29 == null && instance!=null )
                {
                    methodShouldUpdateFocus29 = instance.Type.GetMethod("ShouldUpdateFocus", 1);
                }
                if (methodShouldUpdateFocus29 != null && !isCallingShouldUpdateFocus29)
                {
                    isCallingShouldUpdateFocus29 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                        };
                        object ret = appDomain.Invoke(methodShouldUpdateFocus29, instance, param );
                        
                        
                        isCallingShouldUpdateFocus29 = false;

                        
                        return (System.Boolean)ret;
                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In ShouldUpdateFocus *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                            return default(System.Boolean);
                        
                    

                }
            }
        
        
        
        IMethod methodViewDidAppear30;
        bool isCallingViewDidAppear30= false;
        
            public override void ViewDidAppear(System.Boolean p0) 
            { 
                if (methodViewDidAppear30 == null && instance!=null )
                {
                    methodViewDidAppear30 = instance.Type.GetMethod("ViewDidAppear", 1);
                }
                if (methodViewDidAppear30 != null && !isCallingViewDidAppear30)
                {
                    isCallingViewDidAppear30 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                        };
                        object ret = appDomain.Invoke(methodViewDidAppear30, instance, param );
                        
                        
                        isCallingViewDidAppear30 = false;

                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In ViewDidAppear *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                        
                    

                }
            }
        
        
        
        IMethod methodViewDidDisappear31;
        bool isCallingViewDidDisappear31= false;
        
            public override void ViewDidDisappear(System.Boolean p0) 
            { 
                if (methodViewDidDisappear31 == null && instance!=null )
                {
                    methodViewDidDisappear31 = instance.Type.GetMethod("ViewDidDisappear", 1);
                }
                if (methodViewDidDisappear31 != null && !isCallingViewDidDisappear31)
                {
                    isCallingViewDidDisappear31 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                        };
                        object ret = appDomain.Invoke(methodViewDidDisappear31, instance, param );
                        
                        
                        isCallingViewDidDisappear31 = false;

                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In ViewDidDisappear *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                        
                    

                }
            }
        
        
        
        IMethod methodViewDidLayoutSubviews32;
        bool isCallingViewDidLayoutSubviews32= false;
        
            public override void ViewDidLayoutSubviews() 
            { 
                if (methodViewDidLayoutSubviews32 == null && instance!=null )
                {
                    methodViewDidLayoutSubviews32 = instance.Type.GetMethod("ViewDidLayoutSubviews", 0);
                }
                if (methodViewDidLayoutSubviews32 != null && !isCallingViewDidLayoutSubviews32)
                {
                    isCallingViewDidLayoutSubviews32 = true;

                    try{
                        
                        //无参数调用
                        object ret = appDomain.Invoke(methodViewDidLayoutSubviews32, instance, null );
                        
                        
                        
                        isCallingViewDidLayoutSubviews32 = false;

                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In ViewDidLayoutSubviews *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                        
                    

                }
            }
        
        
        
        IMethod methodViewDidLoad33;
        bool isCallingViewDidLoad33= false;
        
            public override void ViewDidLoad() 
            { 
                if (methodViewDidLoad33 == null && instance!=null )
                {
                    methodViewDidLoad33 = instance.Type.GetMethod("ViewDidLoad", 0);
                }
                if (methodViewDidLoad33 != null && !isCallingViewDidLoad33)
                {
                    isCallingViewDidLoad33 = true;

                    try{
                        
                        //无参数调用
                        object ret = appDomain.Invoke(methodViewDidLoad33, instance, null );
                        
                        
                        
                        isCallingViewDidLoad33 = false;

                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In ViewDidLoad *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                        
                    

                }
            }
        
        
        
        IMethod methodViewDidUnload34;
        bool isCallingViewDidUnload34= false;
        
            public override void ViewDidUnload() 
            { 
                if (methodViewDidUnload34 == null && instance!=null )
                {
                    methodViewDidUnload34 = instance.Type.GetMethod("ViewDidUnload", 0);
                }
                if (methodViewDidUnload34 != null && !isCallingViewDidUnload34)
                {
                    isCallingViewDidUnload34 = true;

                    try{
                        
                        //无参数调用
                        object ret = appDomain.Invoke(methodViewDidUnload34, instance, null );
                        
                        
                        
                        isCallingViewDidUnload34 = false;

                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In ViewDidUnload *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                        
                    

                }
            }
        
        
        
        IMethod methodViewLayoutMarginsDidChange35;
        bool isCallingViewLayoutMarginsDidChange35= false;
        
            public override void ViewLayoutMarginsDidChange() 
            { 
                if (methodViewLayoutMarginsDidChange35 == null && instance!=null )
                {
                    methodViewLayoutMarginsDidChange35 = instance.Type.GetMethod("ViewLayoutMarginsDidChange", 0);
                }
                if (methodViewLayoutMarginsDidChange35 != null && !isCallingViewLayoutMarginsDidChange35)
                {
                    isCallingViewLayoutMarginsDidChange35 = true;

                    try{
                        
                        //无参数调用
                        object ret = appDomain.Invoke(methodViewLayoutMarginsDidChange35, instance, null );
                        
                        
                        
                        isCallingViewLayoutMarginsDidChange35 = false;

                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In ViewLayoutMarginsDidChange *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                        
                    

                }
            }
        
        
        
        IMethod methodViewSafeAreaInsetsDidChange36;
        bool isCallingViewSafeAreaInsetsDidChange36= false;
        
            public override void ViewSafeAreaInsetsDidChange() 
            { 
                if (methodViewSafeAreaInsetsDidChange36 == null && instance!=null )
                {
                    methodViewSafeAreaInsetsDidChange36 = instance.Type.GetMethod("ViewSafeAreaInsetsDidChange", 0);
                }
                if (methodViewSafeAreaInsetsDidChange36 != null && !isCallingViewSafeAreaInsetsDidChange36)
                {
                    isCallingViewSafeAreaInsetsDidChange36 = true;

                    try{
                        
                        //无参数调用
                        object ret = appDomain.Invoke(methodViewSafeAreaInsetsDidChange36, instance, null );
                        
                        
                        
                        isCallingViewSafeAreaInsetsDidChange36 = false;

                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In ViewSafeAreaInsetsDidChange *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                        
                    

                }
            }
        
        
        
        IMethod methodViewWillAppear37;
        bool isCallingViewWillAppear37= false;
        
            public override void ViewWillAppear(System.Boolean p0) 
            { 
                if (methodViewWillAppear37 == null && instance!=null )
                {
                    methodViewWillAppear37 = instance.Type.GetMethod("ViewWillAppear", 1);
                }
                if (methodViewWillAppear37 != null && !isCallingViewWillAppear37)
                {
                    isCallingViewWillAppear37 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                        };
                        object ret = appDomain.Invoke(methodViewWillAppear37, instance, param );
                        
                        
                        isCallingViewWillAppear37 = false;

                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In ViewWillAppear *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                        
                    

                }
            }
        
        
        
        IMethod methodViewWillDisappear38;
        bool isCallingViewWillDisappear38= false;
        
            public override void ViewWillDisappear(System.Boolean p0) 
            { 
                if (methodViewWillDisappear38 == null && instance!=null )
                {
                    methodViewWillDisappear38 = instance.Type.GetMethod("ViewWillDisappear", 1);
                }
                if (methodViewWillDisappear38 != null && !isCallingViewWillDisappear38)
                {
                    isCallingViewWillDisappear38 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                        };
                        object ret = appDomain.Invoke(methodViewWillDisappear38, instance, param );
                        
                        
                        isCallingViewWillDisappear38 = false;

                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In ViewWillDisappear *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                        
                    

                }
            }
        
        
        
        IMethod methodViewWillLayoutSubviews39;
        bool isCallingViewWillLayoutSubviews39= false;
        
            public override void ViewWillLayoutSubviews() 
            { 
                if (methodViewWillLayoutSubviews39 == null && instance!=null )
                {
                    methodViewWillLayoutSubviews39 = instance.Type.GetMethod("ViewWillLayoutSubviews", 0);
                }
                if (methodViewWillLayoutSubviews39 != null && !isCallingViewWillLayoutSubviews39)
                {
                    isCallingViewWillLayoutSubviews39 = true;

                    try{
                        
                        //无参数调用
                        object ret = appDomain.Invoke(methodViewWillLayoutSubviews39, instance, null );
                        
                        
                        
                        isCallingViewWillLayoutSubviews39 = false;

                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In ViewWillLayoutSubviews *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                        
                    

                }
            }
        
        
        
        IMethod methodViewWillTransitionToSize40;
        bool isCallingViewWillTransitionToSize40= false;
        
            public override void ViewWillTransitionToSize(CoreGraphics.CGSize p0, UIKit.IUIViewControllerTransitionCoordinator p1) 
            { 
                if (methodViewWillTransitionToSize40 == null && instance!=null )
                {
                    methodViewWillTransitionToSize40 = instance.Type.GetMethod("ViewWillTransitionToSize", 2);
                }
                if (methodViewWillTransitionToSize40 != null && !isCallingViewWillTransitionToSize40)
                {
                    isCallingViewWillTransitionToSize40 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                                p1,
                        };
                        object ret = appDomain.Invoke(methodViewWillTransitionToSize40, instance, param );
                        
                        
                        isCallingViewWillTransitionToSize40 = false;

                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In ViewWillTransitionToSize *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                        
                    

                }
            }
        
        
        
        IMethod methodViewWillUnload41;
        bool isCallingViewWillUnload41= false;
        
            public override void ViewWillUnload() 
            { 
                if (methodViewWillUnload41 == null && instance!=null )
                {
                    methodViewWillUnload41 = instance.Type.GetMethod("ViewWillUnload", 0);
                }
                if (methodViewWillUnload41 != null && !isCallingViewWillUnload41)
                {
                    isCallingViewWillUnload41 = true;

                    try{
                        
                        //无参数调用
                        object ret = appDomain.Invoke(methodViewWillUnload41, instance, null );
                        
                        
                        
                        isCallingViewWillUnload41 = false;

                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In ViewWillUnload *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                        
                    

                }
            }
        
        
        
        IMethod methodWillAnimateFirstHalfOfRotation42;
        bool isCallingWillAnimateFirstHalfOfRotation42= false;
        
            public override void WillAnimateFirstHalfOfRotation(UIKit.UIInterfaceOrientation p0, System.Double p1) 
            { 
                if (methodWillAnimateFirstHalfOfRotation42 == null && instance!=null )
                {
                    methodWillAnimateFirstHalfOfRotation42 = instance.Type.GetMethod("WillAnimateFirstHalfOfRotation", 2);
                }
                if (methodWillAnimateFirstHalfOfRotation42 != null && !isCallingWillAnimateFirstHalfOfRotation42)
                {
                    isCallingWillAnimateFirstHalfOfRotation42 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                                p1,
                        };
                        object ret = appDomain.Invoke(methodWillAnimateFirstHalfOfRotation42, instance, param );
                        
                        
                        isCallingWillAnimateFirstHalfOfRotation42 = false;

                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In WillAnimateFirstHalfOfRotation *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                        
                    

                }
            }
        
        
        
        IMethod methodWillAnimateRotation43;
        bool isCallingWillAnimateRotation43= false;
        
            public override void WillAnimateRotation(UIKit.UIInterfaceOrientation p0, System.Double p1) 
            { 
                if (methodWillAnimateRotation43 == null && instance!=null )
                {
                    methodWillAnimateRotation43 = instance.Type.GetMethod("WillAnimateRotation", 2);
                }
                if (methodWillAnimateRotation43 != null && !isCallingWillAnimateRotation43)
                {
                    isCallingWillAnimateRotation43 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                                p1,
                        };
                        object ret = appDomain.Invoke(methodWillAnimateRotation43, instance, param );
                        
                        
                        isCallingWillAnimateRotation43 = false;

                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In WillAnimateRotation *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                        
                    

                }
            }
        
        
        
        IMethod methodWillAnimateSecondHalfOfRotation44;
        bool isCallingWillAnimateSecondHalfOfRotation44= false;
        
            public override void WillAnimateSecondHalfOfRotation(UIKit.UIInterfaceOrientation p0, System.Double p1) 
            { 
                if (methodWillAnimateSecondHalfOfRotation44 == null && instance!=null )
                {
                    methodWillAnimateSecondHalfOfRotation44 = instance.Type.GetMethod("WillAnimateSecondHalfOfRotation", 2);
                }
                if (methodWillAnimateSecondHalfOfRotation44 != null && !isCallingWillAnimateSecondHalfOfRotation44)
                {
                    isCallingWillAnimateSecondHalfOfRotation44 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                                p1,
                        };
                        object ret = appDomain.Invoke(methodWillAnimateSecondHalfOfRotation44, instance, param );
                        
                        
                        isCallingWillAnimateSecondHalfOfRotation44 = false;

                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In WillAnimateSecondHalfOfRotation *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                        
                    

                }
            }
        
        
        
        IMethod methodWillMoveToParentViewController45;
        bool isCallingWillMoveToParentViewController45= false;
        
            public override void WillMoveToParentViewController(UIKit.UIViewController p0) 
            { 
                if (methodWillMoveToParentViewController45 == null && instance!=null )
                {
                    methodWillMoveToParentViewController45 = instance.Type.GetMethod("WillMoveToParentViewController", 1);
                }
                if (methodWillMoveToParentViewController45 != null && !isCallingWillMoveToParentViewController45)
                {
                    isCallingWillMoveToParentViewController45 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                        };
                        object ret = appDomain.Invoke(methodWillMoveToParentViewController45, instance, param );
                        
                        
                        isCallingWillMoveToParentViewController45 = false;

                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In WillMoveToParentViewController *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                        
                    

                }
            }
        
        
        
        IMethod methodWillRotate46;
        bool isCallingWillRotate46= false;
        
            public override void WillRotate(UIKit.UIInterfaceOrientation p0, System.Double p1) 
            { 
                if (methodWillRotate46 == null && instance!=null )
                {
                    methodWillRotate46 = instance.Type.GetMethod("WillRotate", 2);
                }
                if (methodWillRotate46 != null && !isCallingWillRotate46)
                {
                    isCallingWillRotate46 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                                p1,
                        };
                        object ret = appDomain.Invoke(methodWillRotate46, instance, param );
                        
                        
                        isCallingWillRotate46 = false;

                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In WillRotate *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                        
                    

                }
            }
        
        
        
        IMethod methodWillTransitionToTraitCollection47;
        bool isCallingWillTransitionToTraitCollection47= false;
        
            public override void WillTransitionToTraitCollection(UIKit.UITraitCollection p0, UIKit.IUIViewControllerTransitionCoordinator p1) 
            { 
                if (methodWillTransitionToTraitCollection47 == null && instance!=null )
                {
                    methodWillTransitionToTraitCollection47 = instance.Type.GetMethod("WillTransitionToTraitCollection", 2);
                }
                if (methodWillTransitionToTraitCollection47 != null && !isCallingWillTransitionToTraitCollection47)
                {
                    isCallingWillTransitionToTraitCollection47 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                                p1,
                        };
                        object ret = appDomain.Invoke(methodWillTransitionToTraitCollection47, instance, param );
                        
                        
                        isCallingWillTransitionToTraitCollection47 = false;

                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In WillTransitionToTraitCollection *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                        
                    

                }
            }
        
        
        
        IMethod methodCanPaste48;
        bool isCallingCanPaste48= false;
        
            public override System.Boolean CanPaste(Foundation.NSItemProvider[] p0) 
            { 
                if (methodCanPaste48 == null && instance!=null )
                {
                    methodCanPaste48 = instance.Type.GetMethod("CanPaste", 1);
                }
                if (methodCanPaste48 != null && !isCallingCanPaste48)
                {
                    isCallingCanPaste48 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                        };
                        object ret = appDomain.Invoke(methodCanPaste48, instance, param );
                        
                        
                        isCallingCanPaste48 = false;

                        
                        return (System.Boolean)ret;
                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In CanPaste *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                            return base.CanPaste(p0);
                        
                    

                }
            }
        
        
        
        IMethod methodCanPerform49;
        bool isCallingCanPerform49= false;
        
            public override System.Boolean CanPerform(ObjCRuntime.Selector p0, Foundation.NSObject p1) 
            { 
                if (methodCanPerform49 == null && instance!=null )
                {
                    methodCanPerform49 = instance.Type.GetMethod("CanPerform", 2);
                }
                if (methodCanPerform49 != null && !isCallingCanPerform49)
                {
                    isCallingCanPerform49 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                                p1,
                        };
                        object ret = appDomain.Invoke(methodCanPerform49, instance, param );
                        
                        
                        isCallingCanPerform49 = false;

                        
                        return (System.Boolean)ret;
                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In CanPerform *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                            return base.CanPerform(p0, p1);
                        
                    

                }
            }
        
        
        
        IMethod methodWillChange50;
        bool isCallingWillChange50= false;
        
            public override void WillChange(Foundation.NSKeyValueChange p0, Foundation.NSIndexSet p1, Foundation.NSString p2) 
            { 
                if (methodWillChange50 == null && instance!=null )
                {
                    methodWillChange50 = instance.Type.GetMethod("WillChange", 3);
                }
                if (methodWillChange50 != null && !isCallingWillChange50)
                {
                    isCallingWillChange50 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                                p1,
                                p2,
                        };
                        object ret = appDomain.Invoke(methodWillChange50, instance, param );
                        
                        
                        isCallingWillChange50 = false;

                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In WillChange *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                        
                    

                }
            }
        
        
        
        IMethod methodWillChange51;
        bool isCallingWillChange51= false;
        
            public override void WillChange(Foundation.NSString p0, Foundation.NSKeyValueSetMutationKind p1, Foundation.NSSet p2) 
            { 
                if (methodWillChange51 == null && instance!=null )
                {
                    methodWillChange51 = instance.Type.GetMethod("WillChange", 3);
                }
                if (methodWillChange51 != null && !isCallingWillChange51)
                {
                    isCallingWillChange51 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                                p1,
                                p2,
                        };
                        object ret = appDomain.Invoke(methodWillChange51, instance, param );
                        
                        
                        isCallingWillChange51 = false;

                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In WillChange *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                        
                    

                }
            }
        
        
        
        IMethod methodWillChangeValue52;
        bool isCallingWillChangeValue52= false;
        
            public override void WillChangeValue(System.String p0) 
            { 
                if (methodWillChangeValue52 == null && instance!=null )
                {
                    methodWillChangeValue52 = instance.Type.GetMethod("WillChangeValue", 1);
                }
                if (methodWillChangeValue52 != null && !isCallingWillChangeValue52)
                {
                    isCallingWillChangeValue52 = true;

                    try{
                        
                        //有参数，打包成数组
                        object[] param=new object[]{
                                p0,
                        };
                        object ret = appDomain.Invoke(methodWillChangeValue52, instance, param );
                        
                        
                        isCallingWillChangeValue52 = false;

                        
                    }
                    catch(Exception e){
                        mb.App.logger.Log("**** Catch Exception In WillChangeValue *****");
                        mb.App.logger.Log(e.ToString());
                        mb.App.logger.Log("**********************");
                        throw e;
                    }
                }
                else
                {
                    
                    
                        
                        
                    

                }
            }
        
        
    }
}